#include <iostream>
#include "tcolaabbporo.h"

using namespace std;

TColaABBPoro::TColaABBPoro()
{
	primero=NULL;
	ultimo=NULL;
}

TColaABBPoro::TColaABBPoro(const TColaABBPoro &cola)
{
	
	if(this!=&cola)
	{
		if(cola.primero==NULL)
		{
				primero=ultimo=NULL;
		}
		else
		{
			TECAP *ant, *auxcopia;
			auxcopia=cola.primero;
			primero=new TECAP(*cola.primero);
			ant = primero;
			ultimo=primero;
			auxcopia=auxcopia->sig;
	//		while(aux.arbol!=cola.ultimo->arbol)
			while( auxcopia != NULL )
			{
				ant->sig = new TECAP(*auxcopia);
				ant = ant->sig;
				ultimo = ant;
				auxcopia=auxcopia->sig;
			}
		}
	}
}

TColaABBPoro::~TColaABBPoro()
{
	if( primero != NULL)
	{
		TECAP *aux;
		aux = primero;
		primero = primero->sig;
		delete aux;
		
		while(primero->sig!=NULL)
		{
				
				aux=primero;
				primero=primero->sig;
				delete aux;
		}
		
		primero=NULL;
		ultimo=NULL;
	}
	else primero = ultimo = NULL;
}

TColaABBPoro &
TColaABBPoro::operator=(const TColaABBPoro &cola)
{
	if(this!=&cola)
	{
		this->~TColaABBPoro();
		if(cola.primero==NULL)
		{
				primero=ultimo=NULL;
		}
		else
		{
			TECAP *ant, *auxcopia;
			auxcopia=cola.primero;
			primero=new TECAP(*cola.primero);
			ant = primero;
			ultimo=primero;
			auxcopia=auxcopia->sig;
	//		while(aux.arbol!=cola.ultimo->arbol)
			while( auxcopia != NULL )
			{
				ant->sig = new TECAP(*auxcopia);
				ant = ant->sig;
				ultimo = ant;
				auxcopia=auxcopia->sig;
			}
		}
	}
	return *this;
}

bool
TColaABBPoro::operator==(const TColaABBPoro &cola){
	
		bool iguales=true;
		TECAP *aux,*aux2;
		aux=cola.primero;
		aux2=this->primero;
		
		while( aux != NULL || aux2 != NULL ) // Recorra hasta que acaben las dos colas
		{
			if(aux != NULL && aux2 != NULL ) // Si ambos tienen nodos en la misma posicion
			{
				if( aux->arbol != NULL && aux2->arbol != NULL)// y estos arboles compara
				{
					if(aux->arbol == aux2->arbol ) iguales = true;
					else iguales = false; // si son distintos
				}
				else iguales = false; // si no tienen arboles los dos
			}
			else iguales = false; // si no tienen el mismo numero de nodos las colas

		}


		
		return iguales;
}


TColaABBPoro
TColaABBPoro::operator+(const TColaABBPoro &cola)
{
	TColaABBPoro colasuma(*this);
	TECAP *rec; // Con este puntero recorremos la cola de la parte derecha.
	rec = cola.primero;
	//buscar elemento;

	while( rec != NULL )
	{
		if( !colasuma.Buscaritem(rec->arbol) ) // Si no esta en la cola encolamos
		{
//			TABBPoro a(*rec->arbol);
			TABBPoro* a = new TABBPoro(*rec->arbol);
			colasuma.Encolar(a);
			rec = rec->sig;
		}
		else // si esta en la cola no hacemos nada y seguimos el proceso
		{
			rec = rec->sig;
		}
	}
	return colasuma;
}

bool //Auxiliar de operator+
TColaABBPoro::Buscaritem(TABBPoro* &arb) const
{
	bool encontrado = false;
	TECAP *rec;
	rec = primero;

	while( !encontrado && rec != NULL )
	{
		if( rec->arbol->Raiz() == arb->Raiz() ) encontrado = true;
		else rec = rec->sig;
	}
	return encontrado;
}

bool
TColaABBPoro::EsVacia()
{
	bool vacia = false;

	if(primero == NULL && ultimo == NULL)
	{
		vacia=true;
	}
	return vacia;
}

bool
TColaABBPoro::Encolar( TABBPoro *p)
{	
	bool encolado=false;

	TECAP *cap = new TECAP();

	if( cap != NULL )
	{
		cap->arbol = p;
		cap->sig = NULL;

		if( ultimo != NULL )
		{
			ultimo->sig = cap;
			ultimo = cap;
		}
		else
		{
			primero = cap;
			ultimo = cap;
		}
		encolado = true;
	}
	/*
	if( ultimo != NULL ) // Sitiene contenido la cola
	{
		ultimo->sig = new TECAP();
		ultimo = ultimo->sig;
		ultimo->arbol = p;
		encolado = true;
	}
	else // Si es una cola vacia.
	{
		primero = ultimo = new TECAP();
		primero->arbol = p;
		encolado = true;
	}*/

	return encolado;
}

bool
TColaABBPoro::Desencolar()
{
	bool desencolado=false;
	
	if(primero!=NULL)
	{
		TECAP *aux;
		aux=primero;
		primero=primero->sig;
		delete aux;
		
		desencolado=true;
		if(primero==NULL)
			ultimo=NULL;
	}
	return desencolado;

}

TABBPoro*
TColaABBPoro::Cabeza()
{
	if( primero!=NULL )
	{
		return primero->arbol;
	}
	else
	{
		return NULL;
	}
}

int
TColaABBPoro::Longitud()
{
		int longitud=0;
		TECAP *aux;
		aux=primero;
		if(!this->EsVacia() )
		{
			while(aux!=NULL)
			{
				longitud++;
				aux=aux->sig;
			}
		}
		return longitud;
}

ostream& operator<<(ostream &os, const TColaABBPoro &cola)
{

	TColaABBPoro caux(cola);

	os << "(";
	while( !caux.EsVacia() )
	{
		if( caux.Cabeza() != NULL )
		{
			os << caux.Cabeza()->Raiz();
		}
		else
		{
			os << ".";
		}
		if( caux.primero != caux.ultimo )
		{
			os << " ";
		}
		caux.Desencolar();

	}
	os << ")";

	return os;
	/*
	os << "(";
	if( cola.primero != NULL )
	{
		TECAP *aux;
		aux=cola.primero;
		while( aux->sig != NULL )
		{
			if( aux->arbol != NULL )
			{
				os << aux->arbol->nodo->item << " ";
			}
			else os << ". ";

			aux = aux->sig;
		}
		//os << aux->arbol->nodo->item;
		if( aux->arbol != NULL )
		{
			os << aux->arbol->nodo->item;
		}
		else os << ".";
	}
	os << ")";
	*/
}

TECAP::TECAP()
{
	arbol=NULL;
	sig=NULL;
}

TECAP::TECAP(const TECAP &t)
{
	if(this!=&t)
	{
		arbol = t.arbol;
		sig = t.sig;
	}
}

TECAP::~TECAP()
{
	arbol=NULL;
	sig=NULL;	
}

TECAP &
TECAP::operator=( const TECAP &t)
{
	if( this != &t )
	{
		arbol = t.arbol;
		sig = t.sig;
	}
	return *this;
}
